// 消息发送相关功能
import { Ref } from 'vue';
import { sendSingleMessage, sendGroupMessage } from '../services/im-message';
import { storageGet, isTauri } from '../services/secure-storage';
import { API_BASE_URL } from '@/config/env';
import { MessageContentType } from '../utils/image';
import type { Message } from './chat-types';

/**
 * 发送消息
 */
export async function sendMessage(
  content: string,
  messageContentType: number,
  fileName: string | undefined,
  fileType: string | undefined,
  currentUserId: Ref<string | null>,
  currentTargetId: Ref<string | null>,
  targetType: Ref<'User' | 'Group'>,
  messages: Ref<Message[]>,
  saveMessagesToStorage: () => Promise<void>,
  fileUrl?: string,
  serverFileName?: string // 服务器生成的文件名（用于下载）
): Promise<Message> {
  // 总是从存储中获取最新的 open_id
  const openId = isTauri()
    ? await storageGet('openId')
    : localStorage.getItem('openId');
  
  if (!openId) {
    throw new Error('未找到用户标识符，请重新登录');
  }
  
  // 如果从存储中获取到了新的 openId，更新 currentUserId.value
  if (currentUserId.value !== openId) {
    console.log('检测到用户ID变化，更新 currentUserId:', currentUserId.value, '->', openId);
    currentUserId.value = openId;
  }
  
  if (!openId || !currentTargetId.value) {
    throw new Error('请先选择聊天对象');
  }
  
  console.log('发送消息，使用用户ID:', {
    openId,
    currentUserId: currentUserId.value,
    targetId: currentTargetId.value,
    targetType: targetType.value,
    content: content.substring(0, 50),
    messageContentType,
    fileName
  });

  // 对于文件消息（message_content_type === 3），允许 content 为空
  // 对于其他类型的消息，content 不能为空
  if (messageContentType !== 3 && (!content || !content.trim())) {
    throw new Error('消息内容不能为空');
  }

  try {
    // 构建 extra 字段
    let extra: string | undefined = undefined;
    if (fileName || fileType || serverFileName) {
      extra = JSON.stringify({ 
        file_name: fileName, // 显示用的原始文件名
        file_type: fileType,
        server_file_name: serverFileName // 服务器文件名（用于下载）
      });
    }

    // 发送消息
    if (targetType.value === 'User') {
      await sendSingleMessage({
        from_id: String(openId),
        to_id: String(currentTargetId.value),
        message_body: content,
        message_content_type: messageContentType,
        extra: extra,
      });
    } else {
      await sendGroupMessage({
        group_id: currentTargetId.value,
        from_id: String(openId),
        message_body: content,
        message_content_type: messageContentType,
        extra: extra,
      });
    }

    // 获取用户信息
    const userStr = isTauri()
      ? (await storageGet('user')) || '{}'
      : localStorage.getItem('user') || '{}';
    const user = JSON.parse(userStr);
    const fromUserId = user.open_id || user.name || String(openId);
    
    // 确保 to_user_id 使用对方的 open_id
    let toUserId = String(currentTargetId.value);
    
    if (targetType.value === 'User') {
      const isNumeric = /^\d+$/.test(toUserId);
      const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(toUserId);
      
      if (!isNumeric && !isUUID) {
        // 可能是用户名，尝试从好友列表获取
        try {
          const friendsStr = localStorage.getItem('friends') || '[]';
          const friends = JSON.parse(friendsStr);
          const friend = friends.find((f: any) => {
            const friendData = f.user || f;
            return friendData.name === toUserId || friendData.open_id === toUserId;
          });
          
          if (friend) {
            const friendData = friend.user || friend;
            if (friendData.open_id) {
              console.log('从好友列表获取 open_id:', toUserId, '->', friendData.open_id);
              toUserId = friendData.open_id;
              if (currentTargetId.value !== friendData.open_id) {
                currentTargetId.value = friendData.open_id;
                console.log('已更新 currentTargetId 为 open_id:', friendData.open_id);
              }
            }
          } else {
            // 如果好友列表中没有，尝试通过 API 获取
            const { getUser } = await import('../services/message');
            const userInfo = await getUser(toUserId);
            if (userInfo && userInfo.open_id) {
              console.log('通过 API 获取 open_id:', toUserId, '->', userInfo.open_id);
              toUserId = userInfo.open_id;
              if (currentTargetId.value !== userInfo.open_id) {
                currentTargetId.value = userInfo.open_id;
                console.log('已更新 currentTargetId 为 open_id:', userInfo.open_id);
              }
            }
          }
        } catch (error) {
          console.warn('无法获取对方的 open_id，使用原值:', toUserId, error);
        }
      }
    }
    
    // 处理图片和文件消息
    let displayMessage = content;
    let messageFileUrl: string | undefined = undefined;
    
    // 如果传入了 fileUrl，直接使用
    if (fileUrl) {
      messageFileUrl = fileUrl;
      // 对于文件消息，将完整 URL 保存到 message_body 中（和图片消息一样）
      if (messageContentType === 3) {
        displayMessage = fileUrl; // 文件消息：完整 URL 作为 message_body
      } else {
        displayMessage = ''; // 图片消息：不显示 URL 文本
      }
    } else if (messageContentType === 2) {
      // 图片消息：从 content 中提取 URL
      if (content.startsWith('data:image/')) {
        messageFileUrl = content;
        displayMessage = '';
      } else if (content.startsWith('/api/upload/')) {
        messageFileUrl = `${API_BASE_URL}${content}`;
        displayMessage = '';
      } else if (content.startsWith('http://') || content.startsWith('https://')) {
        messageFileUrl = content;
        displayMessage = '';
      }
    } else if (messageContentType === 3) {
      // 文件消息：从 content 中提取 URL（如果 content 是 URL）
      if (content.startsWith('/api/upload/')) {
        messageFileUrl = `${API_BASE_URL}${content}`;
        displayMessage = messageFileUrl; // 保留完整 URL 在 message_body 中
      } else if (content.startsWith('http://') || content.startsWith('https://')) {
        messageFileUrl = content;
        displayMessage = content; // 保留完整 URL 在 message_body 中
      }
    }
    
    // 添加到消息列表
    const newMessage: Message = {
      message_id: Date.now().toString(),
      from_user_id: fromUserId,
      to_user_id: toUserId,
      message: displayMessage,
      timestamp_ms: Date.now(),
      timestamp: Date.now(),
      isReceived: false,
      file_url: messageFileUrl,
      file_name: fileName,
      file_type: fileType,
      message_content_type: messageContentType,
      chat_type: targetType.value === 'Group' ? 2 : 1,
    };

    messages.value.push(newMessage);
    
    console.log('📤 发送消息后，准备保存:', {
      fromUserId,
      toUserId,
      openId,
      currentTargetId: currentTargetId.value,
      messageId: newMessage.message_id,
      totalMessages: messages.value.length,
      messageContent: displayMessage.substring(0, 50),
    });
    
    // 保存到存储
    await saveMessagesToStorage();
    
    console.log('✅ 消息保存完成');
    
    return newMessage;
  } catch (error) {
    console.error('发送消息失败:', error);
    throw error;
  }
}

/**
 * 发送通话邀请消息
 */
export async function sendCallInvite(
  targetUserId: string,
  isVoiceOnly: boolean,
  timeout: number = 30,
  currentUserId: Ref<string | null>
): Promise<void> {
  const openId = isTauri()
    ? await storageGet('openId')
    : localStorage.getItem('openId');
  
  if (!openId) {
    throw new Error('未找到用户标识符，请重新登录');
  }
  
  // 构建通话邀请消息内容
  // 注意：包含时间戳，用于客户端判断是否过期
  const inviteContent = JSON.stringify({
    type: 'call_invite',
    isVoiceOnly,
    timeout,
    timestamp: Date.now(), // 发送时间戳，用于客户端判断是否过期
  });
  
  // 发送通话邀请消息
  await sendSingleMessage({
    from_id: String(openId),
    to_id: String(targetUserId),
    message_body: inviteContent,
    message_content_type: MessageContentType.CALL_INVITE,
    extra: undefined,
  });
  
  console.log('✅ 通话邀请消息已发送:', {
    targetUserId,
    isVoiceOnly,
    timeout,
  });
}

/**
 * 发送通话取消/结束消息
 */
export async function sendCallCancel(
  targetUserId: string,
  currentUserId: Ref<string | null>
): Promise<void> {
  const openId = isTauri()
    ? await storageGet('openId')
    : localStorage.getItem('openId');
  
  if (!openId) {
    throw new Error('未找到用户标识符，请重新登录');
  }
  
  // 构建通话取消消息内容
  const cancelContent = JSON.stringify({
    type: 'call_cancel',
    timestamp: Date.now(),
  });
  
  // 发送通话取消消息
  await sendSingleMessage({
    from_id: String(openId),
    to_id: String(targetUserId),
    message_body: cancelContent,
    message_content_type: MessageContentType.CALL_CANCEL,
    extra: undefined,
  });
  
  console.log('✅ 通话取消消息已发送:', {
    targetUserId,
  });
}

